home *** CD-ROM | disk | FTP | other *** search
/ PC User 2003 May / Disc 2 / PCU0503CD2.iso / Crystal / 3rdparty / JavaVM / Plug-in / jplugin.exe / jaws.jar / sun / beanbox / SimpleClassLoader.class (.txt) < prev   
Encoding:
Java Class File  |  1998-06-22  |  8.2 KB  |  328 lines
  1. package sun.beanbox;
  2.  
  3. import java.awt.Toolkit;
  4. import java.beans.Beans;
  5. import java.io.ByteArrayInputStream;
  6. import java.io.File;
  7. import java.io.FileInputStream;
  8. import java.io.IOException;
  9. import java.io.InputStream;
  10. import java.net.URL;
  11. import java.util.Enumeration;
  12. import java.util.Hashtable;
  13. import java.util.Properties;
  14. import java.util.Vector;
  15.  
  16. public class SimpleClassLoader extends ClassLoader {
  17.    public static final String urlPrefix = "SIMPLE";
  18.    private static final String protocolPathProp = "java.protocol.handler.pkgs";
  19.    private static boolean debug;
  20.    private static boolean keepLoading = true;
  21.    private String cookie;
  22.    private static Hashtable loaders = new Hashtable();
  23.    public static SimpleClassLoader ourLoader;
  24.    private String localResourceDirectory;
  25.    private Hashtable localOverrides = new Hashtable();
  26.    private Hashtable resourceHash = new Hashtable();
  27.    private Hashtable mimeHash = new Hashtable();
  28.    private Hashtable rawClasses = new Hashtable();
  29.  
  30.    private SimpleClassLoader(String var1, String var2) {
  31.       this.cookie = var1;
  32.       this.localResourceDirectory = var2;
  33.       loaders.put(var1, this);
  34.    }
  35.  
  36.    public void defineClassFromBytes(String var1, byte[] var2) {
  37.       this.rawClasses.put(var1, var2);
  38.    }
  39.  
  40.    private Class applyDefinition(String var1, boolean var2) {
  41.       byte[] var3 = (byte[])this.rawClasses.get(var1);
  42.       this.rawClasses.remove(var1);
  43.       if (var3 == null) {
  44.          return null;
  45.       } else {
  46.          Object var4 = null;
  47.  
  48.          try {
  49.             var8 = super.defineClass((String)null, var3, 0, var3.length);
  50.             if (var8 != null && var2) {
  51.                ((ClassLoader)this).resolveClass(var8);
  52.             }
  53.          } catch (ClassFormatError var6) {
  54.             System.err.println("The definition for " + var1 + " in the JAR file");
  55.             System.err.println("has a format error.");
  56.             return null;
  57.          } catch (NoClassDefFoundError var7) {
  58.             return null;
  59.          }
  60.  
  61.          if (!var8.getName().equals(var1)) {
  62.             System.err.println("\nWARNING: file name versus class name mismatch");
  63.             String var5 = var1.replace('.', '/') + ".class";
  64.             System.err.println("    JAR entry \"" + var5 + "\" was expected " + "to contain class \"" + var1 + "\"");
  65.             System.err.println("    but instead contained class \"" + var8.getName() + "\"");
  66.             System.err.println("    This may cause future class-loading problems.\n");
  67.          }
  68.  
  69.          return var8;
  70.       }
  71.    }
  72.  
  73.    private static byte[] getByteArray(String var0) throws IOException {
  74.       File var1 = new File(var0);
  75.       int var2 = (int)var1.length();
  76.       byte[] var3 = new byte[var2];
  77.       FileInputStream var4 = new FileInputStream(var0);
  78.  
  79.       int var6;
  80.       for(int var5 = 0; var5 < var2; var5 += var6) {
  81.          var6 = ((InputStream)var4).read(var3, var5, var2 - var5);
  82.          if (var6 < 0) {
  83.             break;
  84.          }
  85.       }
  86.  
  87.       return var3;
  88.    }
  89.  
  90.    public Class loadClassFromFile(String var1) throws ClassNotFoundException {
  91.       try {
  92.          byte[] var2 = getByteArray(var1);
  93.          Class var3 = super.defineClass((String)null, var2, 0, var2.length);
  94.          if (var3 != null) {
  95.             ((ClassLoader)this).resolveClass(var3);
  96.          }
  97.  
  98.          if (var3 == null) {
  99.             throw new ClassNotFoundException(var1);
  100.          } else {
  101.             return var3;
  102.          }
  103.       } catch (Exception var4) {
  104.          debug("LoadFromFile/caught " + var4 + " when loading from file " + var1);
  105.          throw new ClassNotFoundException(var1);
  106.       }
  107.    }
  108.  
  109.    public Class loadClass(String var1) throws ClassNotFoundException {
  110.       return this.loadClass(var1, true);
  111.    }
  112.  
  113.    protected Class loadClass(String var1, boolean var2) throws ClassNotFoundException {
  114.       Class var3 = ((ClassLoader)this).findLoadedClass(var1);
  115.       if (var3 == null) {
  116.          var3 = this.applyDefinition(var1, var2);
  117.       }
  118.  
  119.       if (var3 == null) {
  120.          try {
  121.             var3 = ((ClassLoader)this).findSystemClass(var1);
  122.             return var3;
  123.          } catch (ClassNotFoundException var4) {
  124.          }
  125.       }
  126.  
  127.       if (var3 == null) {
  128.          throw new ClassNotFoundException(var1);
  129.       } else {
  130.          if (var2) {
  131.             ((ClassLoader)this).resolveClass(var3);
  132.          }
  133.  
  134.          return var3;
  135.       }
  136.    }
  137.  
  138.    public Object instantiate(String var1, InputStreamProducer var2) throws ClassNotFoundException, IOException {
  139.       String var3 = var1.replace('.', '/');
  140.       Object var4 = null;
  141.  
  142.       try {
  143.          this.setLocalResourceSource(var3 + ".ser", var2);
  144.          var4 = Beans.instantiate(this, var1);
  145.       } finally {
  146.          this.localOverrides.remove(var3 + ".ser");
  147.       }
  148.  
  149.       return var4;
  150.    }
  151.  
  152.    public void setLocalResourceSource(String var1, InputStreamProducer var2) {
  153.       this.localOverrides.put(var1, var2);
  154.    }
  155.  
  156.    void putClassResource(String var1, String var2) {
  157.       this.resourceHash.put(var1, "A CLASS FILE");
  158.       this.mimeHash.put(var1, var2);
  159.    }
  160.  
  161.    void putLocalResource(String var1, byte[] var2, String var3) {
  162.       this.resourceHash.put(var1, var2);
  163.       this.mimeHash.put(var1, var3);
  164.    }
  165.  
  166.    public URL getResource(String var1) {
  167.       URL var2 = ClassLoader.getSystemResource(var1);
  168.       return var2 != null ? var2 : this.getLocalResource(var1);
  169.    }
  170.  
  171.    public InputStream getResourceAsStream(String var1) {
  172.       InputStream var2 = ClassLoader.getSystemResourceAsStream(var1);
  173.       return var2 != null ? var2 : this.getLocalResourceAsStream(var1);
  174.    }
  175.  
  176.    public URL getLocalResource(String var1) {
  177.       Object var2 = this.localOverrides.get(var1);
  178.       if (var2 == null) {
  179.          var2 = this.resourceHash.get(var1);
  180.       }
  181.  
  182.       if (var2 == null && this.localResourceDirectory != null) {
  183.          File var3 = new File(this.localResourceDirectory, var1);
  184.          if (var3.exists()) {
  185.             var2 = new Integer("1");
  186.          }
  187.       }
  188.  
  189.       if (var2 != null) {
  190.          try {
  191.             URL var5 = new URL("simpleresource", "", "/SIMPLE" + this.cookie + "/+/" + var1);
  192.             return var5;
  193.          } catch (Exception var4) {
  194.             debug("Exception " + var4 + " while building a resource URL");
  195.             return null;
  196.          }
  197.       } else {
  198.          return null;
  199.       }
  200.    }
  201.  
  202.    private InputStream getLocalResourceAsStream(String var1) {
  203.       Object var2 = this.localOverrides.get(var1);
  204.       if (var2 != null) {
  205.          return ((InputStreamProducer)var2).getInputStream();
  206.       } else {
  207.          var2 = this.resourceHash.get(var1);
  208.          if (var2 != null) {
  209.             if (var2 instanceof String) {
  210.                throw new SecurityException("No access through getResource() to .class in 1.1");
  211.             } else {
  212.                byte[] var6 = (byte[])var2;
  213.                return new ByteArrayInputStream(var6);
  214.             }
  215.          } else if (this.localResourceDirectory != null) {
  216.             File var3 = new File(this.localResourceDirectory, var1);
  217.  
  218.             try {
  219.                return new FileInputStream(var3);
  220.             } catch (Exception var4) {
  221.                return null;
  222.             }
  223.          } else {
  224.             return null;
  225.          }
  226.       }
  227.    }
  228.  
  229.    public static SimpleClassLoader createLoader(String var0, String var1) {
  230.       SimpleClassLoader var2 = getLoader(var0);
  231.       if (var2 != null) {
  232.          if (!var2.localResourceDirectory.equals(var1)) {
  233.             throw new Error("internal error!");
  234.          } else {
  235.             return var2;
  236.          }
  237.       } else {
  238.          return new SimpleClassLoader(var0, var1);
  239.       }
  240.    }
  241.  
  242.    private static SimpleClassLoader getLoader(String var0) {
  243.       return (SimpleClassLoader)loaders.get(var0);
  244.    }
  245.  
  246.    public static Object getLocalResource(String var0, String var1) {
  247.       SimpleClassLoader var2 = getLoader(var0);
  248.       Object var3 = var2.localOverrides.get(var1);
  249.       if (var3 != null) {
  250.          return ((InputStreamProducer)var3).getInputStream();
  251.       } else {
  252.          String var4 = (String)var2.mimeHash.get(var1);
  253.          if (var4 != null) {
  254.             var3 = var2.resourceHash.get(var1);
  255.             if (var3 instanceof String) {
  256.                throw new SecurityException("No access through getResource() to .class in 1.1");
  257.             } else {
  258.                byte[] var9 = (byte[])var3;
  259.                return var4.startsWith("image") ? Toolkit.getDefaultToolkit().createImage(var9).getSource() : new ByteArrayInputStream(var9);
  260.             }
  261.          } else {
  262.             if (var2.localResourceDirectory != null) {
  263.                File var5 = new File(var2.localResourceDirectory, var1);
  264.                if (var5.exists()) {
  265.                   try {
  266.                      URL var6 = new URL("file", "", var5.getAbsolutePath());
  267.                      return var6.getContent();
  268.                   } catch (Exception var7) {
  269.                      throw new Error("no such resource");
  270.                   }
  271.                }
  272.             }
  273.  
  274.             return null;
  275.          }
  276.       }
  277.    }
  278.  
  279.    public static InputStream getLocalResourceAsStream(String var0, String var1) {
  280.       SimpleClassLoader var2 = getLoader(var0);
  281.       return var2.getLocalResourceAsStream(var1);
  282.    }
  283.  
  284.    public synchronized boolean applyDefinitions(Vector var1) {
  285.       boolean var2 = true;
  286.       Enumeration var3 = var1.elements();
  287.  
  288.       while(var3.hasMoreElements()) {
  289.          String var4 = (String)var3.nextElement();
  290.          Class var5 = ((ClassLoader)this).findLoadedClass(var4);
  291.          if (var5 == null) {
  292.             var5 = this.applyDefinition(var4, true);
  293.             if (var5 == null) {
  294.                if (var2) {
  295.                   System.err.println("NOTE: There are classes that cannot be defined in this JAR file");
  296.                   System.err.println("    Some of these classes will cause the failure of defining or linking ");
  297.                   System.err.println("    other classes that depend on them.");
  298.                   if (keepLoading) {
  299.                      System.err.println("NOTE: To simplify debugging JAR files, we will proceed loading classes");
  300.                      System.err.println("    although this may lead eventually to an UnknownError or the like");
  301.                      System.err.println();
  302.                   }
  303.                }
  304.  
  305.                System.err.println("Class " + var4 + " could not be defined from JAR file");
  306.                var2 = false;
  307.             }
  308.          }
  309.       }
  310.  
  311.       return var2;
  312.    }
  313.  
  314.    private static void debug(String var0) {
  315.       if (debug) {
  316.          System.err.println("SimpleClassLoader:: " + var0);
  317.       }
  318.  
  319.    }
  320.  
  321.    static {
  322.       Properties var0 = new Properties(System.getProperties());
  323.       ((Hashtable)var0).put("java.protocol.handler.pkgs", var0.getProperty("java.protocol.handler.pkgs") + "|sun.beanbox");
  324.       System.setProperties(var0);
  325.       ourLoader = createLoader("BeanBox", (String)null);
  326.    }
  327. }
  328.